// // 实现一个发布订阅 https://blog.csdn.net/lucky569/article/details/118542497

// class Event {
//   constructor() {
//     this.events = {}
//   }
//   // 订阅事件
//   on(type, callback) {
//     // this.events[type] = callback
//     // 如果events里面有type这个属性，则push回调函数，否则重新建立
//     (this.events[type] || (this.events[type] = [])).push({listener: callback})
//   }
//   // 发布事件
//   emit(type, args) {
//     // this.events[type](args)
//     // this.events[type].forEach(element => {
//     //   element(args)
//     // })
//     // addEventListener第三个参数有个once.我在需要once的click加个属性?
//     console.log('???:', this.events[type])
//     this.events[type] && this.events[type].forEach(element => {
//       element.listener(args);
//       if (type === 'once') {
//         this.off(type, element.listener)
//       }
//     })
//   }
//   // once事件
//   once(type, listener) {
//     this.events[type] = this.events[type] || []
//     this.events[type].push({listener, once: true})
//   }
//   // 关闭事件
//   off(type, callback) {
//     if (this.events[type]) {
//       this.events[type] = this.events[type].filter(item => item.listener !== callback)
//     }
//   }
// }

// const e = new Event

// e.on('click', x => console.log(x.id))
// e.on('click', x => console.log(x.id))
// e.on('click', x => console.log(x.id))



// e.emit('click', {id: 3})
// e.emit('once', {content: '只执行一次'})




// // js 实现一个控制一步最大并发数的函数

// class LimitPromise {
//   constructor (limit) {
//     this._limit = limit // 最大限制数
//     this._count = 0 // 目前并发的数量
//     this._taskQueue = [] // 如果并发数等于最大限制，则把新加的异步操作用数组存起来
//   }
// }
 
// LimitPromise.prototype.call = function (asyncFn, ...args) {
//   return new Promise((resolve, reject) => {
//     const task = this.createTask(asyncFn, args, resolve, reject)
//     if (this._count >= this._limit) {
//       this._taskQueue.push(task)
//     } else {
//       task()
//     }
//   })
// }
 
// LimitPromise.prototype.createTask = function (asyncFn, args, resolve, reject) {
//   return () => {
//     asyncFn(...args)
//       .then(resolve)
//       .catch(reject)
//       .finally(() => {
//         this._count--
//         if (this._taskQueue.length) {
//           let task = this._taskQueue.shift()
//           task()
//         }
//       })
 
//     this._count++
//   }
// }
 
// let limitP = new LimitPromise(3)

function Foo() {
  getName = function() {
    console.log(5)
  }
  return this
}
Foo.getName = function() {
  console.log(4)
}
Foo.prototype.getName = function() {
  console.log(3)
}
var getName = function() {
  console.log(2)
}
function getName() {
  console.log(1)
}

Foo.getName();
getName();
// Foo().getName();
getName();
new Foo.getName();
new Foo().getName();
new new Foo().getName();


console.log([1, 2, 3].map(parseInt)) // 1 NaN NaN
/**
 * 如果没有传进制，主要分两情况

如果要解析的字符串以 0x 或者 0X 开头，则以16进制进行解析
如果要解析的字符串以 0 开头，则以八进制或者十进制进行解析，在ECMAScript5中指明要以十进制进行解析，但浏览器兼容存在问题，最好指定第二个参数
其余情况默认按照十进制解析
如果传递了第二个参数

如果第二个参数为 undefined， 0 ， null 则以十进制进行解析
如果进制数小于 2 或大于 36 ,则返回NaN
 * [1,2,3].map(function(item, index, arr){
      return parseInt(item, index, arr);
  })
 */




// promise 封装axios